
import wx from "weixin-js-sdk";
import CryptoJS from 'crypto-js';
import jspdf from 'jspdf';
import html2canvas from 'html2canvas';
import {
	apiBaseUrl,
} from '@/common/config/api.js';
import store from '@/store';
import pagesConfig from '@/pages.json';


const settings = {
	// 十六位十六进制数作为密钥
	secretKey: CryptoJS.enc.Utf8.parse("Ds3wu2xzs1wqkjdh"),
	// 十六位十六进制数作为密钥偏移量
	secretIv: CryptoJS.enc.Utf8.parse('Ds3wu2xzs1wqkjdh'),
};
/**
 * 根据接口响应的文件数据流，打开文件
 * @param {*} requestUrl 请求地址
 * @param {*} data 请求的参数
 */
export const cusDownloadFile = (requestUrl, data, method = 'GET') => {
	uni.request({
		url: `${apiBaseUrl}${requestUrl}`, // 你的文件下载地址
		method,
		header: {
			Authorization: 'Bearer ' + store.state.accessToken,//后台的tokrn
		},
		data,
		responseType: 'arraybuffer', // 设置响应类型为arraybuffer以接收二进制数据
		success: (res) => {
			// 获取接口放在响应头的文件名称
			const disposition = res.header["Content-Disposition"] || res.header['content-disposition'];
			const ss = disposition.split(";");
			let fileName = "";
			for (const s of ss) {
				if (s.indexOf("filename*") > -1) {
					const ff = s.split("=");
					let f = ff[1];
					f = f.replace("UTF-8", "");
					f = f.replace("''", "");
					fileName = decodeURIComponent(f);
					break;
				}
			}
			// 文件类型
			const fileNames = fileName.split(".");
			const len = fileNames.length;
			// 后缀
			const suffix = fileNames[len - 1];
			// 文件名
			const name = fileNames.slice(0, len - 1)[0];

			// 文件保存路径
			const filePath = `${wx.env.USER_DATA_PATH}/${name}${new Date().getTime()}.${suffix}`;
			const fs = uni.getFileSystemManager();
			// 写入文件到指定的本地文件路径
			fs.writeFile({
				filePath: filePath, // 本地文件路径
				data: res.data,
				success: () => {
					// console.log(filePath, suffix, 'openDocument');
					// 打开文件
					uni.openDocument({
						filePath: filePath,  // 本地文件路径
						fileType: suffix,	// 如果没有fileType属性，pc端小程序打开文件失败
						showMenu: true,
						success: function (res) {
							console.log('打开文档成功');
						}
					})
				},
				fail: (writeErr) => {
					console.error('文件写入失败', writeErr);
				}
			});
		},
		fail: (err) => {
			console.error('文件下载失败', err);
		}
	});
}

/**
 * 文件上传
 * @param {*} requestUrl 请求地址
 * @param {*} url uniapp文件临时文件路径
 * @param {*} type 接口需要拼接在url上的参数值
 * @param {*} name 文件参数名
 * @param {*} isLoading 是否显示loading
 * @returns 
 */
export const cusUploadFilePromise = (requestUrl, url, name = 'file', type = '', isLoading = true) => {
	if (isLoading) {
		uni.showLoading({
			mask: true,
			title: '加载中... '
		});
	}
	return new Promise((resolve, reject) => {
		uni.uploadFile({
			url: `${apiBaseUrl}${requestUrl}${type}`,
			filePath: url, // uniapp文件临时文件路径
			header: {
				Authorization: 'Bearer ' + store.state.accessToken,
			},
			name,
			success: (uploadFileRes) => {
				setTimeout(() => {
					console.log(JSON.parse(uploadFileRes.data), 'JSON.parse(uploadFileRes.data)');
					let { data, success } = JSON.parse(uploadFileRes.data);
					if (success) {
						resolve(data[0])
					} else {
						resolve(false);
					}
				}, 1000)
			},
			fail() {
				resolve(false)
			},
			complete() {
				if (isLoading) {
					uni.hideLoading();
				}
			}
		});
	})
}

/**
 * 识别图片文本
 * @param {*} requestUrl 请求地址
 * @param {*} url uniapp文件临时文件路径
 * @param {*} name 文件参数名
 * @param {*} type 接口需要拼接在url上的参数值
 * @param {*} isLoading 是否显示loading
 * @returns 
 */
export const cusUploadOcrPromise = (requestUrl, url, name = 'file', type = '', isLoading = true) => {
	console.log(url, 'uploadOcrPromise')
	if (isLoading) {
		uni.showLoading({
			mask: true,
			title: '加载中... '
		});
	}
	return new Promise((resolve, reject) => {
		uni.uploadFile({
			url: `${apiBaseUrl}${requestUrl}${type}`,
			filePath: url, // uniapp图片临时文件路径
			header: {
				Authorization: 'Bearer ' + store.state.accessToken,
			},
			name,
			success: (uploadFileRes) => {
				console.log(uploadFileRes, 'uploadFileRes')
				setTimeout(() => {
					resolve(uploadFileRes.data.replace(/(\n|\r|\r\n|↵)/g, '<br />'))
				}, 1000)
			},
			fail() {
				resolve(false)
			},
			complete() {
				if (isLoading) {
					uni.hideLoading();
				}
			}
		});
	})
}


/**
 * 深度克隆(对象。数组)
 * @param {*} obj 需要克隆的数据
 * @param {*} newObj 克隆完之后的新数据
 * @returns 
 */
export const cusDeepClone = (obj, newObj) => {
	if (obj instanceof Array) { // 判断是否是数组
		newObj = [];
		return cusDeepCloneArray(obj, newObj);
	} else if (obj instanceof Object && typeof obj === 'object') { // 判断是否是对象
		newObj = {};
		return cusDeepCloneObject(obj, newObj);
	} else {
		return newObj = obj;
	}
}
/**
 * 克隆对象
 * @param {*} obj 需要克隆的对象
 * @param {*} newObj 克隆完之后的新对象
 * @returns 
 */
function cusDeepCloneObject(obj, newObj) {
	for (var temp in obj) {
		if (obj.hasOwnProperty(temp)) { // 过滤原型属性
			if (obj[temp] instanceof Object || obj[temp] instanceof Array) { // 如果还是对象或者数组继续递归深层克隆
				var tempNewObj = {};
				newObj[temp] = cusDeepClone(obj[temp],
					tempNewObj);
			} else { // 不是直接赋值
				newObj[temp] = obj[temp];
			}
		}
	}
	return newObj;
}
/**
 * 克隆数组
 * @param {*} obj 需要克隆的数组
 * @param {*} newObj 克隆完之后的新数组
 * @returns 
 */
function cusDeepCloneArray(arr, newArr) {
	for (var i = 0; i < arr.length; i++) {
		if (arr[i] instanceof Object || arr[i] instanceof Array) { // 如果还是对象或者数组继续递归深层克隆
			var tempNewObj;
			newArr[i] = cusDeepClone(arr[i], tempNewObj);
		} else { // 不是直接赋值
			newArr[i] = arr[i];
		}
	}
	return newArr;
}


/**
 * JS获取指定日期的前一天，后一天
 * @param {*} date 代表指定的日期，格式：2018-09-27
 * @param {*} day 传-1表始前一天，传1表始后一天
 * @returns 
 */
export function cusGetNextDate(date, day) {
	let dd = new Date(date);
	dd.setDate(dd.getDate() + day);
	let y = dd.getFullYear();
	let m = dd.getMonth() + 1 < 10 ? "0" + (dd.getMonth() + 1) : dd.getMonth() + 1;
	let d = dd.getDate() < 10 ? "0" + dd.getDate() : dd.getDate();
	return y + "-" + m + "-" + d;
}


/**
 * 文件大小显示单位
 * @param {*} size 上传文件时得到的size数值
 * @returns 
 */
export function cusTransformSize(size) {
	if (size < 1024) {
		// B
		return size + 'B'
	} else if (size / 1024 / 1024 >= 1) {
		// MB
		return (size / 1024 / 1024).toFixed(2) + 'MB'
	} else {
		// KB
		return (size / 1024).toFixed(2) + 'KB'
	}
}

/**
 * 生成一个指定长度的随机字符串
 * @param {*} size 指定生成的字符串长度
 * @returns 
 */
export function cusRandomString(size = 12) {
	let urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict'
	let id = ''
	let i = size
	while (i--) {
		id += urlAlphabet[(Math.random() * 64) | 0]
	}
	return id
}


/**
 * 
 * 退回已经存在且匹配到的路由
 * @param {路由} route 页面路径
 * 
 * 注: uniapp开发使用
 * 
 * 例如：
 * const route = 'oa-approval/DataInfo/DataInfo';
 * navigatorBackRoute(route);
 */
export function cusNavigatorBackRoute(route) {
	const routeList = getCurrentPages();
	let index = 1;
	routeList.forEach((item, i) => {
		if (item.route === route) {
			index = i;
		}
	})
	uni.$emit('refresh');
	uni.navigateBack({
		delta: routeList.length - index - 1
	});
}


/**
 * 获取微信小程序顶部状态条的高度值
 * @returns 
 * 
 * 注: uniapp开发使用
 */
export function cusInitStatusBarHeight() {
	let statusHeight = 48;
	const systemInfo = uni.getSystemInfoSync()
	statusHeight = systemInfo.statusBarHeight ? systemInfo.statusBarHeight * 2 : statusHeight;
	// #ifdef MP-WEIXIN
	const menuButtonInfo = uni.getMenuButtonBoundingClientRect();
	statusHeight = menuButtonInfo.top * 2;
	// #endif
	return statusHeight;
}


/**
 * H5预览附件的情况（微信环境、浏览器环境、微信小程序环境）
 * @param {*} fileName 文件名
 * @param {*} filePath 文件路径
 * 
 * 注: uniapp开发使用
 */
export function cusPreviewDoc(fileName, filePath) {
	var ua = navigator.userAgent.toLowerCase();
	if (ua.match(/MicroMessenger/i) == "micromessenger") {
		//ios的ua中无miniProgram，但都有MicroMessenger（表示是微信浏览器）
		wx.miniProgram?.getEnv((res) => {
			if (res.miniprogram) {
				// 微信小程序环境
				wx.miniProgram.navigateTo({
					url: `/pages/integration/previewDoc/index?title=${fileName}&url=${encodeURIComponent(filePath)}`
				})
			} else {
				// 微信环境打开的链接
				window.location.href = filePath;
			}
		})
	} else {
		// 不是微信环境
		window.location.href = filePath;
	}
}


/**
 * AES加密函数
 * @param {*} value 明文数据
 * @returns 返回加密结果
 */
export function cusKeyEncrypt(value) {
	return CryptoJS.AES.encrypt(value, settings.secretKey, { iv: settings.secretIv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 }).toString();
}

/**
 * AES解密函数
 * @param {*} encryptedValue 密文数据
 * @returns 返回解密结果
 */
export function cusKeyDecrypt(encryptedValue) {
	var bytes = CryptoJS.AES.decrypt(encryptedValue, settings.secretKey, { iv: settings.secretIv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
	return bytes.toString(CryptoJS.enc.Utf8);
}

/**
 * 存储cookie
 * @param {*} name 属性名
 * @param {*} value 属性值
 * @param {*} seconds 过期秒数
 * @param {*} isEncrypt 是否加密
 * 
 * 注: 涉及到document，仅限浏览器环境使用
 */
export function cusSetCookie(name, value, seconds = 60, isEncrypt = false) {
	var expires = "";
	var date = new Date();
	date.setTime(date.getTime() + seconds * 1000);
	expires = "; expires=" + date.toUTCString();
	document.cookie = name + "=" + (isEncrypt ? cusKeyEncrypt(value) : value) + expires + "; path=/";
}


/**
 * 获取cookie
 * @param {*} name 属性名
 * @returns 
 * 
 * 注: 涉及到document，仅限浏览器环境使用
 */
export function getCookie(name) {
	// 将document.cookie字符串按照; 分割成数组
	var cookies = document.cookie.split(';');
	// 修剪字符串两侧的空格
	name = name + "=";
	for (var i = 0; i < cookies.length; i++) {
		var cookie = cookies[i].trim();
		// 检查当前cookie是否是目标cookie
		if (cookie.indexOf(name) == 0)
			return cookie.substring(name.length, cookie.length);
	}
	return ""; // 如果没有找到，返回空字符串
}


/**
 * 
 * @param {*} urls 图片路径数组
 * @param {*} executionDefault 处理函数
 * @returns 
 */
function cusImageSegmentation(urls, executionDefault) {
	// #ifndef H5
	executionDefault()
	// #endif
	// #ifdef H5
	if (urls.length > 1) return executionDefault();
	const url = urls[0];
	if (!url.includes('jpg') && !url.includes('jpeg') && !url.includes('png')) return executionDefault();
	const img = new Image();
	img.setAttribute("crossOrigin", 'Anonymous')
	img.onload = () => {
		const canvas = document.createElement('canvas');
		const ctx = canvas.getContext('2d');
		const quantity = parseInt(img.height / img.width / 3)
		if (quantity < 2) return executionDefault();

		const width = img.width;
		const height = parseInt(img.height / quantity);
		const overflowHeight = parseInt(height * 1.1);
		const dataURLs = []
		for (let index = 0; index < quantity; index++) {
			canvas.width = width;
			canvas.height = (index * height + overflowHeight) > img.height ? (img.height - index * height) : overflowHeight;
			ctx.drawImage(img, 0, index * height, canvas.width, canvas.height, 0, 0, canvas.width, canvas.height);
			const dataUrl = canvas.toDataURL('image/png')
			dataURLs.push(dataUrl)
		}
		uni.previewImage({
			current: 0, urls: dataURLs, longPressActions: {
				itemList: ['保存原始图片'],
				success: function () {
					uni.saveImageToPhotosAlbum({ filePath: url });
				}
			}
		});
	}
	img.onerror = (e) => {
		console.log(e)
		executionDefault()
	};
	img.src = url; // 设置图像的源  
	// #endif
}


/**
 * 图片预览功能
 * @param {*} urls 图片路径数组
 * @param {*} current 可以是图片的链接，或者图片的下标
 * 
 * 注: uniapp开发使用
 */
export const cusPerviewImages = (urls, current = 0) => {
	// 预览图片
	// #ifndef APP-PLUS
	cusImageSegmentation(urls, () => {
		uni.previewImage({
			current,
			urls,
		});
	})
	// #endif
	// #ifdef APP-PLUS
	plus.nativeUI.previewImage(urls, {
		"background": "#ffffff"
	});
	// #endif
}


/**
 * 
 * 获取所有页面完整路径
 * @returns 
 * 
 * 注: uniapp开发使用
 */
export function cusGetPagePaths() {
	// 页面路径
	let pagePaths = [];
	// 主包页面路径
	pagePaths.push(...cusGetPagePath(pagesConfig.pages));
	// 分包页面路径
	pagesConfig?.subPackages?.forEach(item => {
		pagePaths.push(...cusGetPagePath(item.pages, item.root));
	});
	return pagePaths;
}

/**
 * 获取页面路径
 * @param {*} pages 所有页面
 * @param {*} root 某一页面路径
 * @returns 
 * 
 * 注: uniapp开发使用
 */
function cusGetPagePath(pages, root) {
	let path = [];
	pages?.forEach(page => {
		path.push({
			path: `${root ? `/${root}` : ''}/${page.path}`,
			title: `${page.style?.navigationBarTitleText}`
		});
	});
	return path;
}


/**
 * 平铺树形数据
 * @param {*} list 需要平铺的数组数据
 * @param {*} prop 需要平铺的属性名
 * @returns 
 */
export function cusTileTreeData(list, prop = 'children') {
	let ls = [];
	if (!list || list.length === 0) return ls;
	list.forEach((item) => {
		if (item.type !== prop) {
			ls.push(item);
		} else {
			ls = ls.concat(cusTileTreeData(item.children));
		}
	});
	return ls;
}


/**
 * 输入框聚焦时滚动到输入框的可视区域
 * @param {*} id 输入框的id
 * 
 * 注: uniapp开发使用
 */
export function cusScrollIntoView(id) {
	// 获取系统信息
	const systemInfo = uni.getSystemInfoSync();
	// 判断是手机端还是电脑端（手机使用的时候才需要滚动）
	if (systemInfo.platform === 'android' || systemInfo.platform === 'ios') {
		// 获取DOM元素
		// #ifdef H5
		let el = document.getElementById(id);
		el?.scrollIntoView({
			behavior: "smooth",
			block: "end",
			inline: "end",
		});
		// #endif
	}
}

/**
 * 输入框聚焦时滚动到输入框的可视区域
 * @param {*} id 输入框的id
 * @param {*} positionY 需要滚动到指定的页面位置(输入框在y轴的位置 - 键盘的高度(大约是292))
 * 
 * 注: uniapp开发使用，准确度尚不精确
 */
export function cusScrollIntoView2(id, positionY) {
	// 获取系统信息
	const systemInfo = uni.getSystemInfoSync();
	// 判断是手机端还是电脑端（手机使用的时候才需要滚动）
	if (systemInfo.platform === 'android' || systemInfo.platform === 'ios') {
		// 获取DOM元素
		let view = uni.createSelectorQuery().select(`#${id}`);
		view
			.boundingClientRect((res) => {
				console.log(res, positionY, "boundingClientRect");
				if (res) {
					uni.pageScrollTo({
						scrollTop: positionY,
					});
				}
			})
			.exec();
	}
}

/**
 * 生成网页pdf，只有一页
 * @param {*} el 要导出的HTML元素
 * @param {*} formName pdf文件名
 */
export function cusCreateOnePagePdf(el, formName) {
	const opts = {
		scale: 2, // 设置html2canvas的比例
		useCORS: true // 允许跨域图片下载
	};
	html2canvas(el, opts).then(canvas => {
		// 创建图片对象
		var img = new Image();
		img.src = canvas.toDataURL('image/png');
		console.log(img, 'imgimgimgimgimgimgimgimg');
		// 创建 PDF 对象
		var pdf = new jspdf.jsPDF();

		// 将图片添加到 PDF 中
		img.onload = function () {
			pdf.addImage(img, 'PNG', 0, 0, pdf.internal.pageSize.getWidth(), pdf.internal.pageSize.getHeight());
			pdf.save(`${formName}.pdf`);
		};
	});
}



/**
 * 生成网页pdf，如果有多页，则根据手机屏幕大小进行分页
 * @param {*} el 要导出的HTML元素
 * @param {*} formName pdf文件名
 * 
 * 注: uniapp开发使用
 */
export function cusCreatePagePdf(el, formName) {
	uni.showLoading({
		mask: true,
		title: `${this.$t("common.loading")}...`,
	});
	el.style.height = "auto";
	el.style.width = "fit-content";
	setTimeout(() => {
		const pageHeight = el.scrollHeight; // 获取元素的总高度
		const pageWidth = el.scrollWidth; // 获取元素的总宽度
		console.log(pageHeight, pageWidth, 'pageHeight, pageWidth, ...................');
		const canvas = document.createElement("canvas"); // 创建canvas元素
		// const ctx = canvas.getContext("2d"); // 创建canvas上下文
		const scale = 2; // 设置canvas的比例，以便生成清晰的PDF

		canvas.height = pageHeight * scale; // 设置canvas高度
		canvas.width = pageWidth * scale; // 设置canvas宽度

		const opts = {
			scale: scale, // 设置html2canvas的比例
			canvas: canvas, // 指定转换的canvas
			useCORS: true, // 允许跨域图片下载
		};

		html2canvas(el, opts).then((canvas) => {
			// console.log(canvas, 'canvas, ...................');
			let w = 375; // 屏幕宽度
			let h = 750; // 屏幕高度
			uni.getSystemInfo({
				success: function (info) {
					w = info.windowWidth;
					h = info.windowHeight;
				}
			});
			// const pdf = new jspdf("p", "mm", "a4"); // 创建新的jsPDF实例，a4纸有属于自己的宽高
			const pdf = new jspdf("p", "mm", [w, h]); // 创建新的jsPDF实例, [375, 750]为手机端的宽高
			// console.log(pdf, 'pdf, ...................');

			const imgData = canvas.toDataURL("image/jpeg"); // 将canvas转换为图片
			const imgProps = pdf.getImageProperties(imgData); // 获取图片属性
			console.log(imgProps, 'imgProps');
			const pdfWidth = pdf.internal.pageSize.getWidth(); // PDF页面宽度
			const pdfHeight = (imgProps.height * pdfWidth) / imgProps.width; // 根据宽度计算高度
			let heightLeft = pdfHeight;

			const pageHeight = pdf.internal.pageSize.getHeight(); // PDF页面高度
			// console.log(pdfWidth, pdfHeight, pageHeight, 'pdfWidth, pdfHeight, pageHeight, ...................');
			let position = 0;

			pdf.addImage(imgData, "JPEG", 0, position, pdfWidth, pdfHeight); // 添加图片到PDF

			// 如果内容超过一页
			if (pageHeight < heightLeft) {
				heightLeft -= pageHeight;

				while (heightLeft >= 0) {
					position = heightLeft - pdfHeight;
					pdf.addPage();
					pdf.addImage(imgData, "JPEG", 0, position, pdfWidth, pdfHeight);
					heightLeft -= pageHeight;
				}
			}
			uni.hideLoading();
			el.style.height = "100%";
			el.style.width = "100%";
			const pdfSrc = pdf.output("bloburi");
			console.log(pdfSrc, formName, "pdfSrc, formName");
			// pdf.save('表单详情.pdf'); // 保存PDF
			// return;
			// 提示是否预览文件
			uni.showModal({
				title: "提示",
				content: "是否预览需要导出的pdf页面",
				success: async (res) => {
					if (res.confirm) {
						// 确认导出，调用api上传到后端
						uni.showLoading({
							mask: true,
							title: `${this.$t("common.loading")}...`,
						});
						const name = formName + ".pdf";
						const lindex = name.lastIndexOf(".");
						const type = name.substr(lindex);
						const res2 = await getOSSPolicyToken();
						console.log(res2, "res2");
						if (res2.data.success) {
							console.log(res2.data);
							const ossConfig = res2.data.data;
							const newFileName = `${moment().format(
								"YYYYMMDDHHmmssSS"
							)}_${randomString(5)}${type}`;
							const headerParams = {
								name: name,
								key: ossConfig.dir + newFileName,
								policy: ossConfig.policy,
								OSSAccessKeyId: ossConfig.accessid,
								success_action_status: "200", //让服务端返回200,不然，默认会返回204
								callback: ossConfig.callback,
								signature: ossConfig.signature,
							};
							if (ossConfig.securityToken) {
								this.$set(
									headerParams,
									"x-oss-security-token",
									ossConfig.securityToken
								);
							}
							console.log(
								headerParams,
								ossConfig,
								"headerParams, ossConfig"
							);
							// 获取图片路径接口
							const result = await ossUploadFilePromise(
								pdfSrc,
								ossConfig.host,
								headerParams,
								false,
								this
							);
							console.log(
								result,
								"result >>>>>>>>>>>>>>>>. 获取图片路径接口"
							);
							if (result) {
								if (result.downloadAddress) {
									// 接口返回的文件需要有文件链接
									let viewPath = result.downloadAddress;
									//oss
									if (result.downloadKey) {
										const { data } = await getOSSDownloadUrlByKey({
											key: result.downloadKey,
											isPreview: true,
										});
										if (data.success) {
											// viewPath = getViewUrl(data.data.downloadAddress)
											viewPath = data.data.original;
										}
										cusPreviewDoc(formName, viewPath);
									}
								} else {
									this.$refs.uToast.show({
										type: "error",
										message: this.$t("common.submit-failed"),
									});
								}
							} else {
								this.$refs.uToast.show({
									type: "error",
									message: res.data.msg,
								});
							}
						}
						uni.hideLoading();
					}
				},
			});
		});
	}, 1000)
}

/**
 * 根据子id获取所有父id集合
 * @param {*} tree 树形结构数据
 * @param {*} childId 子id
 * @param {*} parentIds 所有父id集合
 * @param {*} originTree 树的源数据
 * @returns
 */
export function getAllParentIds(tree, childId, parentIds = [], originTree = []) {
	// 遍历每个节点
	for (let node of tree) {
		// 如果找到了子节点，将其id加入parentIds并递归检查其父节点
		if (node.id === childId) {
			if (node.parentid) {
				parentIds.unshift(node.parentid); // 将父id添加到数组前端
				this.getAllParentIds(originTree, node.parentid, parentIds, originTree); // 继续查找更高层级的父节点
			}
			return parentIds; // 返回找到的所有父id
		}
		// 如果节点有子节点，继续递归查找
		if (node.children && node.children.length > 0) {
			const parents = this.getAllParentIds(node.children, childId, parentIds, originTree);
			if (parents.length) return parents; // 如果找到了，立即返回
		}
	}
	return parentIds; // 如果没有找到，返回空数组
}
